package cn.mujiankeji.mbrowser.功能.播放框

import android.content.pm.ActivityInfo
import android.os.Build
import android.view.View
import android.view.Window
import android.view.WindowInsets
import android.view.WindowInsetsController
import android.view.WindowManager
import androidx.appcompat.app.AppCompatActivity
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.media3.exoplayer.ExoPlayer
import java.util.concurrent.TimeUnit

/**
 * 将毫秒格式化为时间字符串 (HH:MM:SS 或 MM:SS)
 */
fun Long.格式化为时间(): String {
    if (this <= 0) return "00:00"
    
    val 小时 = TimeUnit.MILLISECONDS.toHours(this)
    val 分钟 = TimeUnit.MILLISECONDS.toMinutes(this) % 60
    val 秒 = TimeUnit.MILLISECONDS.toSeconds(this) % 60
    
    return if (小时 > 0) {
        String.format("%02d:%02d:%02d", 小时, 分钟, 秒)
    } else {
        String.format("%02d:%02d", 分钟, 秒)
    }
}

/**
 * 将进度百分比转换为毫秒
 * @param 总时长 视频总时长(毫秒)
 * @param 百分比 进度百分比(0.0-1.0)
 * @return 对应的毫秒数
 */
fun 百分比转毫秒(总时长: Long, 百分比: Float): Long {
    return (总时长 * 百分比.coerceIn(0f, 1f)).toLong()
}

/**
 * 将毫秒转换为进度百分比
 * @param 当前位置 当前位置(毫秒)
 * @param 总时长 视频总时长(毫秒)
 * @return 对应的进度百分比(0.0-1.0)
 */
fun 毫秒转百分比(当前位置: Long, 总时长: Long): Float {
    if (总时长 <= 0) return 0f
    return (当前位置.toFloat() / 总时长).coerceIn(0f, 1f)
}

/**
 * 切换全屏模式
 * @param 活动 Activity实例
 * @param 全屏 是否启用全屏
 */
fun 切换全屏模式(活动: AppCompatActivity, 全屏: Boolean) {
    if (全屏) {
        // 设置全屏
        活动.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
        隐藏系统UI(活动.window)
    } else {
        // 退出全屏
        活动.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
        显示系统UI(活动.window)
    }
}

/**
 * 隐藏系统UI
 * @param 窗口 Window实例
 */
fun 隐藏系统UI(窗口: Window) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        窗口.insetsController?.let { controller ->
            controller.hide(WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars())
            controller.systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
        }
    } else {
        @Suppress("DEPRECATION")
        窗口.decorView.systemUiVisibility = (
            View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
            or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
            or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
            or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
            or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
            or View.SYSTEM_UI_FLAG_FULLSCREEN
        )
    }
}

/**
 * 显示系统UI
 * @param 窗口 Window实例
 */
fun 显示系统UI(窗口: Window) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        窗口.insetsController?.show(WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars())
    } else {
        @Suppress("DEPRECATION")
        窗口.decorView.systemUiVisibility = (
            View.SYSTEM_UI_FLAG_LAYOUT_STABLE
            or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
            or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
        )
    }
}

/**
 * 保持屏幕常亮
 * @param 窗口 Window实例
 * @param 常亮 是否保持屏幕常亮
 */
fun 保持屏幕常亮(窗口: Window, 常亮: Boolean) {
    if (常亮) {
        窗口.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
    } else {
        窗口.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
    }
}

/**
 * 生命周期感知的屏幕常亮控制
 * 当Composable在前台时保持屏幕常亮，离开时恢复正常
 */
@Composable
fun 屏幕常亮效果() {
    val 上下文 = LocalContext.current
    val 活动 = 上下文 as? AppCompatActivity
    val 生命周期所有者 = LocalLifecycleOwner.current
    
    DisposableEffect(生命周期所有者) {
        val 观察者 = LifecycleEventObserver { _, 事件 ->
            if (事件 == Lifecycle.Event.ON_RESUME) {
                活动?.window?.let { 保持屏幕常亮(it, true) }
            } else if (事件 == Lifecycle.Event.ON_PAUSE) {
                活动?.window?.let { 保持屏幕常亮(it, false) }
            }
        }
        
        生命周期所有者.lifecycle.addObserver(观察者)
        
        onDispose {
            活动?.window?.let { 保持屏幕常亮(it, false) }
            生命周期所有者.lifecycle.removeObserver(观察者)
        }
    }
}

/**
 * 获取视频格式名称
 * @param 播放器 ExoPlayer实例
 * @return 视频格式名称
 */
fun 获取视频格式名称(播放器: ExoPlayer?): String {
    if (播放器 == null) return "未知"
    
    val 轨道索引 = 播放器.currentTrackGroups
    if (轨道索引.isEmpty) return "未知"
    
    for (i in 0 until 轨道索引.length) {
        val 轨道组 = 轨道索引.get(i)
        for (j in 0 until 轨道组.length) {
            val 格式 = 轨道组.getFormat(j)
            if (格式.sampleMimeType?.startsWith("video/") == true) {
                return when {
                    格式.sampleMimeType?.contains("avc") == true -> "H.264"
                    格式.sampleMimeType?.contains("hevc") == true -> "H.265"
                    格式.sampleMimeType?.contains("vp9") == true -> "VP9"
                    格式.sampleMimeType?.contains("av01") == true -> "AV1"
                    else -> 格式.sampleMimeType?.replace("video/", "") ?: "未知"
                }
            }
        }
    }
    
    return "未知"
}

/**
 * 获取当前视频分辨率
 * @param 播放器 ExoPlayer实例
 * @return 分辨率字符串 (例如: "1920x1080")
 */
fun 获取视频分辨率(播放器: ExoPlayer?): String {
    if (播放器 == null) return "未知"
    
    val 视频大小 = 播放器.videoSize
    if (视频大小.width <= 0 || 视频大小.height <= 0) return "未知"
    
    return "${视频大小.width}x${视频大小.height}"
}

/**
 * 获取当前视频比特率
 * @param 播放器 ExoPlayer实例
 * @return 比特率 (Kbps)
 */
fun 获取视频比特率(播放器: ExoPlayer?): Int {
    if (播放器 == null) return 0
    
    val 轨道索引 = 播放器.currentTrackGroups
    if (轨道索引.isEmpty) return 0
    
    var 最高比特率 = 0
    
    for (i in 0 until 轨道索引.length) {
        val 轨道组 = 轨道索引.get(i)
        for (j in 0 until 轨道组.length) {
            val 格式 = 轨道组.getFormat(j)
            if (格式.sampleMimeType?.startsWith("video/") == true) {
                if (格式.bitrate > 最高比特率) {
                    最高比特率 = 格式.bitrate
                }
            }
        }
    }
    
    return 最高比特率 / 1000 // 转换为Kbps
}

/**
 * 检查播放器是否支持画质切换
 * @param 播放器 ExoPlayer实例
 * @return 是否支持画质切换
 */
fun 是否支持画质切换(播放器: ExoPlayer?): Boolean {
    if (播放器 == null) return false
    
    val 轨道组 = 播放器.currentTrackGroups
    if (轨道组.isEmpty) return false
    
    var 视频轨道数 = 0
    for (i in 0 until 轨道组.length) {
        val 组 = 轨道组.get(i)
        for (j in 0 until 组.length) {
            val 格式 = 组.getFormat(j)
            if (格式.sampleMimeType?.startsWith("video/") == true) {
                视频轨道数++
                if (视频轨道数 > 1) return true
            }
        }
    }
    
    return false
} 